package com.zzb;

import com.zzb.polymorphism.Animal;
import com.zzb.polymorphism.Cat;
import com.zzb.polymorphism.Dog;
import com.zzb.polymorphism.Pig;

public class Test {
    public static void main(String[] args) {
        Animal d = new Dog();
        Animal c = new Cat();
        Animal p = new Pig();

        d.eat();
        c.eat();
        p.eat();
    }
}

class Demo02 {
    //定义一个成员内部类
    class Inner {
        public void show() {
            System.out.println(" Inner show. . . ");
        }
    }
}


class Demo02Test {
    public static void main(String[] args) {
        //创建Demo02对象
        Demo02 demo02 = new Demo02();
        //通过Demo02对象创建Inner对象
        Demo02.Inner inner = demo02.new Inner();
        //调用show方法
        inner.show();
    }
}


class Outer {
    public int num = 10;

    // outer类中的成员变量num，值为10
    class Inner {
        public int num = 20;

        // Inner类中的成员变量num，值为20
        public void show() {
            int num = 30;
            //show方法的局部变量num，值为30
            System.out.println(num);
            System.out.println( this.num );
            System.out.println( Outer.this.num);
        }
    }
}

//测试类
class InnerClassTest {

    public static void main(String[] args) {

        Outer. Inner oi = new Outer().new Inner();

        oi.show();
    }
}


interface Animal1{
    void show();
}

class Cat1 implements Animal1{
    public void show(){
        System.out.println("猫");
    }
}

class Test1{

    public static void main(String[] args){
        fun(new Cat1());//请用普通的子类的形式调用

        fun(new Animal1() {
            @Override
            public void show() {
                System.out.println("匿名内部类操作");
            }
        });//请用匿名内部类的形式调用

        fun(() -> System.out.println("Lambda表达式实现"));//Lambda表达式实现
    }

    public static void fun(Animal1 a ){
        a.show();
    }
}


interface Flyable {
    void fly(String s);
}

/*
    Lambda表达式的格式：(形式参数) -> {代码块}

    练习2：
        1:定义一个接口(Flyable)，里面定义一个抽象方法：void fly(String s);
        2:定义一个测试类(FlyableDemo)，在测试类中提供两个方法
            一个方法是：useFlyable(Flyable f)
            一个方法是主方法，在主方法中调用useFlyable方法
 */
class FlyableDemo {
    public static void main(String[] args) {
        //在主方法中调用useFlyable方法
        //匿名内部类
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("飞机自驾游");
            }
        });
        System.out.println("--------");

        //Lambda
        useFlyable((String s) -> {
            System.out.println(s);
            System.out.println("飞机自驾游");
        });

    }

    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }
}


interface Addable {
    int add(int x,int y);
}

/*
    Lambda表达式的格式：(形式参数) -> {代码块}

    练习3：
        1:定义一个接口(Addable)，里面定义一个抽象方法：int add(int x,int y);
        2:定义一个测试类(AddableDemo)，在测试类中提供两个方法
            一个方法是：useAddable(Addable a)
            一个方法是主方法，在主方法中调用useAddable方法
 */
class AddableDemo {
    public static void main(String[] args) {
        //在主方法中调用useAddable方法
        useAddable((int x,int y) -> {
            return x + y;
//            return  x - y;
        });

    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

class Test2{
    public static void main(String[] args) {
        Integer integer = 12;

        System.out.println(integer);
    }
}